package com.xinye.demo.ui

import android.os.Bundle
import android.view.View
import com.droid.library.app.BaseActivity
import com.droid.library.log.Logger
import io.reactivex.Observable
import io.reactivex.ObservableSource
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.functions.Function
import io.reactivex.schedulers.Schedulers

class RxJavaTestActivity : BaseActivity() {

    companion object {
        val TAG = RxJavaTestActivity::class.java.simpleName
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        printMessage("print message in onCreate method")

//        switchThread()
//        exampleMap()
        exampleFlatMap()
    }

    private fun exampleFlatMap() {
        Observable.fromArray(1,2,3,4)
                .flatMap {
                    val list = listOf(1 + it,3 + it,5 + it)
                    Observable.fromArray(list)
                }
                .subscribe{
                    printMessage("$it")
                }
    }

    private fun exampleMap() {
        Observable.create<Int> {
                    it.onNext(1)
                    it.onComplete()
                }.subscribeOn(Schedulers.io())
                .map {"${it.javaClass.simpleName} to String - map execute - $it" }
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({printMessage("OnNext:$it")},{printMessage("onError:$it")})
    }

    private fun switchThread() {
        /**
         *
         * refs:https://www.jianshu.com/p/8818b98c44e2
         *
         * 多次指定上游的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.
         * 多次指定下游的线程是可以的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.
         *
         * Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
         * Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
         * Schedulers.newThread() 代表一个常规的新线程
         * AndroidSchedulers.mainThread() 代表Android的主线程
         *
         * 看似很完美, 但我们忽略了一点, 如果在请求的过程中Activity已经退出了,
         * 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了Disposable ,
         * 说它是个开关, 调用它的dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件,
         * 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.
         *
         *
         * 那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable,
         * 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候,
         * 调用CompositeDisposable.clear() 即可切断所有的水管.
         *
         *
         */
        Observable.create<Int> {
            printMessage("Observable send message")
            it.onNext(1)
            it.onNext(2)
            it.onNext(3)
//                    it.onError(RuntimeException("runtime exception"))
            it.onComplete()
        }
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.computation())
                .doOnNext({printMessage("doOnNext - $it")})
                .filter({it >= 2})
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(
                        {printMessage("onNext accept - $it") },
                        {printMessage("onError accept - $it")
                        })
    }

    private fun printMessage(message : String){
        Logger.i(TAG,"currentThread:${Thread.currentThread().name},message:$message")
    }

    override fun onClick(v: View?) {
    }

    override fun getPageName(): String {
        return ""
    }
}